import { Controller } from 'egg';
import {Op} from "sequelize";
import {existsSync,statSync,unlinkSync} from 'fs';
export default class  ProductController extends Controller {
    
    //产品列表接口
    /**
     * @api {get} /mamage/product_list 产品列表
     * @apiName manageProductList
     * @apiGroup Product
     * @apiVersion 1.0.0
     * @apiDescription 产品列表
     * @apiParam {String} keyword  关键字查询
     * @apiParam {Number} page  页面位置
     * @apiParam {Number} page_size  页面尺寸
     * @apiParam {Number} category_id  类型ID
     * @apiParam {Number} sub_id  子类型ID
     * @apiSuccess {Number} code 返回状态码 0失败  200成功
     * @apiSuccess {String} message 返回状态对应提示消息
     * @apiSuccess {Object} data 查询返回结果
     * @apiSuccess {Object[]} data.data_info 产品列表
     * @apiSuccess {String} data.data_info.product_id 产品ID 
     * @apiSuccess {String} data.data_info.product_name 产品名称
     * @apiSuccess {String} data.data_info.sort 产品排序
     * @apiSuccess {String} data.data_info.create_time 创建时间
     * @apiSuccess {String} data.data_info.category_name 产品类型名称
     * @apiSuccess {String} data.data_info.sub_name 产品子类型名称
     * @apiSuccess {String} data.data_info.sub_id 产品子类型Id
     * @apiSuccess {String} data.data_info.category_id 产品类型ID
     */
    /**
     * 分页查询所有产品
     * 参数：
     *  condition 检索条件
     * 输出：
     * {Number} code 返回状态码 0失败  200成功
     * {String} message 返回状态对应提示消息
     * {Object} data 查询返回结果
     * {Object[]} data.data_info 产品列表
     * {String} data.data_info.product_id 产品ID 
     * {String} data.data_info.product_name 产品名称
     * {String} data.data_info.sort 产品排序
     * {String} data.data_info.create_time 创建时间
     * {String} data.data_info.category_name 产品类型名称
     * {String} data.data_info.sub_name 产品子类型名称
     * {String} data.data_info.sub_id 产品子类型Id
     * {String} data.data_info.category_id 产品类型ID
     * 过程：
     *  构建分页查询条件
     *  分页查询数据，分页结果处理逻辑，返回结果
     */
    async list(){
        let {ctx}=this;
        const {query}=ctx.request;
        try {
            let condition:any={}
            if(query.keyword){
                let keyword=query.keyword;
                condition['product_name']={[Op.like]: '%'+ keyword +'%'};
            }
            
            if(query.category_id){
                condition['category_id']=query.category_id;
            }
            if(query.sub_id){
                condition['sub_id']=query.sub_id;
            }
            let order_condition=[
                ['create_time', 'DESC']
            ];
            //ctx.helper.sort_order(order_condition);
            let product_list=await ctx.service.product.find_and_count_all(condition,order_condition,query);
            ctx.body=product_list
        } catch (error) {
            ctx.body=ctx.helper.error_result("查询异常");
        }
    }
    
    //产品详情
    /**
     * @api {get} /manage/product_info 产品详情
     * @apiName manageProductInfo
     * @apiGroup Product
     * @apiVersion 1.0.0
     * @apiDescription 产品详情
     * @apiParam {Number} product_id  产品ID
     * @apiSuccess {Number} code 返回状态码 0失败  200成功
     * @apiSuccess {String} message 返回状态对应提示消息
     * @apiSuccess {Object} data 查询结果结构
     * @apiSuccess {String} data.product_name 产品名称
     * @apiSuccess {String} data.product_id 产品ID
     * @apiSuccess {Object[]} data.resource 产品内容数组
     * @apiSuccess {Number} data.resource.resource_id 产品内容资源ID
     * @apiSuccess {String} data.resource.resource_name 产品内容资源名称
     * @apiSuccess {String} data.resource.resource_url 资源路径
     * @apiSuccess {String} data.resource.resource_content 产品内容资源对应视频路径
     * @apiSuccess {Number} data.category_id 产品分类ID
     * @apiSuccess {String} data.category_name 产品分类名称
     * @apiSuccess {String} data.sub_name 产品子分类名称
     * @apiSuccess {Number} data.sub_id 产品子分类ID
     * @apiSuccess {String} data.create_time 产品创建时间
     * 
     */
    async info(){
        let {ctx}=this;
        const {query}=ctx.request;
        let product_id=query.product_id;
        if(!product_id){
            return ctx.body=ctx.helper.error_result("没有指定需要查询的产品ID")
        }
        let  result=await ctx.service.product.find_one({product_id});
        ctx.body=result
    }
    //产品修改
    /**
     * @api {get} /manage/product_update 产品修改
     * @apiName manageProductUpdate
     * @apiGroup Product
     * @apiVersion 1.0.0
     * @apiDescription 产品修改
     * @apiParam {Number} product_id  产品ID
     * @apiParam {String} product_name 产品名称
     * @apiParam {Number} category_id  分类ID
     * @apiParam {Number} sub_id  子分类ID
     * @apiParam {Object[]} resource  资源对象 
     * @apiParam {String} resource.resource_content 描述文本字符串，可为空
     * @apiParam {String} resource.resource_name  文本标题
     * @apiParam {String} resource.resource_url  资源路径
     * @apiSuccess {Number} code 返回状态码 0失败  200成功
     * @apiSuccess {String} message 返回状态对应提示消息
     * 
     */
    /**
     * 过程：
     * 修改产品字段，删除资源记录数据，删除对应资源文件
     */
    async update(){
        const {ctx,app} = this;
        let {body}=ctx.request;
        let {Product,Resource}=app.model;
        if(!body.product_id){
            return ctx.body=ctx.helper.error_result("没有指定需要修改的产品ID")
        }
        let update_obj=ctx.helper.assign_basic({},body);
        try {
            let result=await Product.update({...update_obj},{where:{product_id:body.product_id}});
            if(result){
                if(body.resource&&body.resource.length>0){
                    await Resource.destroy({where:{parent_id:body.product_id,type:1}});
                    let resources=body.resource;
                    if(resources&&resources.length>0){
                        await ctx.service.common.set_resource(resources,{type:1,parent_id:body.product_id,resource_name:body.product_name})
                    }
                }
                return ctx.body=ctx.helper.success_result("修改产品成功");
            }
        } catch (error) {
            console.log(error)
        }
        ctx.body=ctx.helper.error_result("修改产品失败");
    }
    //产品新增
    /**
     * @api {get} /manage/product_add 产品新增
     * @apiName manageProductAdd
     * @apiGroup Product
     * @apiVersion 1.0.0
     * @apiDescription 产品新增
     * @apiParam {Number} category_id  类型ID
     * @apiParam {Number} sub_id  子类型ID
     * @apiParam {Object[]} resource  资源对象 
     * @apiParam {String} resource.resource_content 描述文本字符串，可为空
     * @apiParam {String} resource.resource_name  文本标题
     * @apiParam {String} resource.resource_url  资源路径
     * @apiParam {String} product_name 产品名称
     * @apiSuccess {Number} code 返回状态码 0失败  200成功
     * @apiSuccess {String} message 返回状态对应提示消息
     * 
     */
    async add(){
        const {ctx,app} = this;
        let {body}=ctx.request;
        
        try {
            let product=ctx.helper.assign_basic({},body);
            let result=await app.model.Product.create(product);
            let product_id=result['product_id'];
            let resources=body.resource;
            if(resources&&resources.length>0){
                await ctx.service.common.set_resource(resources,{type:1,parent_id:product_id,resource_name:body.product_name})
            }
            
            ctx.body=ctx.helper.success_result("添加产品成功");
        } catch (error) {
            ctx.body=ctx.helper.error_result("添加产品失败");
        }
        
    }
    //删除产品
    /**
     * @api {post} /manage/product_del 产品删除（删除时会将产品对应的资源一并删除，注意提示）
     * @apiName manageProductDel
     * @apiGroup Product
     * @apiVersion 1.0.0
     * @apiDescription 产品删除
     * @apiParam {Number} product_id  产品ID
     * @apiSuccess {Number} code 返回状态码 0失败  200成功
     * @apiSuccess {String} message 返回状态对应提示消息
     * 
     */
    /**
     * 过程：
     * 产品删除，查找产品下所有资源，删除这些资源记录，并删除资源文件
     * 删除对应产品记录
     */
    async del(){
        const {ctx,app} = this;
        let {body}=ctx.request;
        let {Product,Resource}=app.model;
        if(!body.product_id){
            return ctx.body=ctx.helper.error_result("没有指定需要修改的产品ID")
        } 
        try {
            let del_condition={where:{parent_id:body.product_id,type:1}};
            let resources=await Resource.findAll(del_condition);
            console.log(resources);
            if(resources.length>0){
                await Resource.destroy(del_condition)
                resources.map(ele=>{
                    let origin_url=ctx.service.resource.get_origin_url(ele)
                    if(existsSync(origin_url)&&statSync(origin_url).isFile()){
                        unlinkSync(origin_url);
                    }
                });
            }
            let result=await Product.destroy({where:{product_id:body.product_id}});
            console.log(result);
            if(result){
                return ctx.body=ctx.helper.success_result("删除成功");
            }else{
                return ctx.body=ctx.helper.success_result("未删除数据");
            }
        } catch (error) {
            console.log(error);
        }
        ctx.body=ctx.helper.error_result("删除产品失败")
    }
    /**
     * @api {get} /manage/product_add_query 产品新增查询
     * @apiName manageProductAddQuery
     * @apiGroup Product
     * @apiVersion 1.0.0
     * @apiDescription 产品新增查询
     * @apiSuccess {Number} code 返回状态码 0失败  200成功
     * @apiSuccess {String} message 返回状态对应提示消息
     * @apiSuccess {Object[]} data 返回数据
     * @apiSuccess {Number} data.category_id 类型ID
     * @apiSuccess {String} data.category_name 类型名称
     * @apiSuccess {Object[]} data.sub_categories 子类数组
     * @apiSuccess {Number} data.sub_categories.sub_id 子类ID
     * @apiSuccess {String} data.sub_categories.sub_name 子类名称
     * 
     * 
     */
    /**
     * 过程：
     * 查询所有的类型，关联查询子类型
     * 遍历结果构建类型列表，其中每个类型中包含子类型列表
     */
    async add_query(){
        let {ctx,app}=this;
        const {Category,Sub,SubCategory} =app.model;
        console.log("hello");
        try {
            let category:object[]=await Category.findAll({
                include:[
                    {
                        model:SubCategory,
                        attributes:['sub_id'],
                        association:Category.hasMany(SubCategory,{foreignKey:'category_id'}),
                        include:[{
                            model:Sub,
                            attributes:['sub_id','sub_name'],
                            association:SubCategory.belongsTo(Sub,{foreignKey:'sub_id'})
                        }]
                    }
                ],
                attributes:['category_id','category_name']
            })
            if(category){
                category=JSON.parse(JSON.stringify(category));
                category.map(ele=>{
                    ctx.helper.dot_filter(ele);
                    if(ele['sub_categories']&&ele['sub_categories'].length>0){
                        ele['sub_categories'].map(sub=>{
                            if(sub['sub']&&sub['sub']['sub_name']){
                                sub['sub_name']=sub['sub']['sub_name']
                            }
                            delete sub['sub'];
                        })
                    }
                })
                return ctx.body=ctx.helper.success_result("操作成功",category);
            }
        } catch (error) {
            console.log(error);
        }
        return ctx.body=ctx.helper.error_result("未找到数据");
    }
}

